package tu.traffic.plane.linklist;

import tu.traffic.plane.node.Node;

public class plane_list {
    public Node head;

    public plane_list(){
        this.head = new Node();                             //调用结点初始化中的无参构造函数完成对头结点的建立
    }
    
    // 尾插法
    public void create1(Object[] Id, Object[] temp, Object[] temp2)throws Exception{
        Node rear = this.head;	//尾指针rear
        if(temp == null)
            throw new Exception("空对象异常");
        if(temp.length == 0)
            System.out.println("当前暂无任何航班");
        for(int i = 0; i < temp.length; i++){
            rear.next = new Node(Id[i], temp[i], temp2[i], null);
            rear = rear.next;		//尾指针自赋值，指向新的尾结点
        }
    }

    // // 头插法
    // public void create2(Object[] Id, Object[] temp, Object[] temp2) throws Exception{        //将Demo中的数组进行传递
    //     // Node head = this.head;                          //头结点
    //     if(temp == null)
    //         throw new Exception("空对象异常");
    //     if(temp.length == 0)                            
    //         System.out.println("传递数组为空");
    //     for (int i = 0; i < temp.length; i++) {         //利用for循环进行逐个插入
    //         Node node = new Node(Id[i], temp[i], temp2[i], null);         //建立新结点
    //         node.next = this.head.next;                              //将原本首结点的地址赋予给新结点
    //         this.head.next = node;                              //将新结点地址赋予首结点
    //     }   
    // }

    //将一个已经存在的带头结点单链表制成空表
    public void clear(){
        head.planeId = null;
        head.startTime = null;
        head.arrTime = null;
        head.next = null;
        System.out.println("航班信息已被清空");
    } 
    // 判断带头结点的单链表是否为空
    public boolean isEmpty(){
        return head.next == null;
    }
    // 求带头结点的单链表的长度
    public int length(){
        Node p = head.next;                 //初始化，p指向首结点，length为计数器
        int length = 0;                     
        while(p != null){                   //从首结点开始向后查找，直到p为空
            p = p.next;                     //指向后继结点
            ++length;                       //长度增1
        }
        return length;
    }

    //按航班号查找
    //返回第几趟航班
    public int search(Object key) throws Exception{
        if(key == null)
            throw new Exception("输入航班信息错误");
        int i = -1;                                                             
        for(Node p = this.head.next; p != null; p = p.next){        //p这里指向头结点，不是首结点；p自赋值
            i++;
            if(p.planeId.equals(key))                                  //p指向结点的数据域与需要寻找元素进行对比
                return i;                                           //返回位置
        }
        throw new Exception("暂无此航班");
    }


    
    // // 读取带头结点的单链表中的第i个结点
    // public Object get(int i) throws Exception{
    //     if(i < 0)									//防御代码
	// 		throw new Exception("序号输入错误！");
    //     Node p = head.next;                         //初始化，p指向首结点，j为计数器
    //     int j = 0;
    //     while(p != null && j < i){
    //         p = p.next;
    //         ++j;
    //     }
    //     if(j > i || p == null){
    //         throw new Exception("第" + i + "个元素不存在");
    //     }
    //     return p.data;
    // }

    // // 在带头结点的单链表中的第i个结点之前插入一个值为x的新节点
    // public void insert(int i, Object x) throws Exception{
    //     if(x == null)
    //         throw new Exception("不能插入空对象");
    //     Node p = this.head;								//p指向头结点
    //     for(int j = 0; p.next != null && j < i; j++)	// 寻找插入位置
    //         p = p.next;
    //     p.next = new Node(x, p.next);
    // }

    //插入到最后一个结点之后
    public void insert(Object planeId, Object startTime, Object arrTime) throws Exception{
        if(planeId == null || startTime == null || arrTime == null){
            throw new Exception("传入数据为空！");
        }
        Node p = this.head;
        while(p.next != null){
            p = p.next;
        }
        p.next = new Node(planeId, startTime, arrTime,null);
    }

    // 删除带头结点的单链表中的第i个结点
    public Object remove(int i) throws Exception{
        if(i >= 0 && i < length()){
            Node p = this.head;                 //p目前为头指针
            //定位到待删除结点(i)的前驱结点(i - 1)
            for(int j = 0; p.next != null && j < i; j++){
                p = p.next;
            }
            if(p.next != null){
                Object old = ((String)p.next.arrTime + p.next.planeId + p.next.startTime).toString();//获取原对象
                p.next = p.next.next;//删除p的后继结点
                return old;
            }
        }
        //当i < 0或大于表长时
        return null;
    }

    // 在带头结点的单链表中查找值为x的结点
    //按起飞时间查找航班信息
    public Object indexOf(Object x) throws Exception {
        Node p = head.next;                             //初始化，p指向首结点，j为计数器
        // int j = 0;
        // 下面从单链表中的首结点开始查找，直到p.data为x或到达单链表的表尾
        while(p != null && !p.startTime.equals(x)){
            p = p.next;                                 //指向下一个结点
            // ++j;                                        //计数器+1
        }
        if(p != null)
            // return j;                                   //返回值为x的结点在单链表中的位置
            return p.planeId;
        else
            throw new Exception("查无此航班！");                                  //值为x的结点不在单链表中，则返回-1
    }

    // 输出单链表中的所有结点
    public void display(){
        Node node = head.next;                          //取出带头结点的单链表中的首结点
        System.out.println("航班号    起飞时间    到达时间");
        while(node != null)                             
        {
            System.out.println(node.planeId+"       "+node.startTime+"       "+node.arrTime+ "    ");        //输出结点的值
            node = node.next;                           //取下一个结点
        }
        System.out.println();                           //换行
    }

    public void showInfor(){
        Node p = head.next;
        
    }
}
